package com.hu.system.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.hu.common.core.domain.entity.SysUser;
import com.hu.common.exception.ServiceException;
import com.hu.common.utils.SecurityUtils;
import com.hu.common.utils.StringUtils;
import com.hu.system.domain.ProductInfo;
import com.hu.system.mapper.ProductInfoMapper;
import com.hu.system.mapper.PurchaseInboundMapper;
import com.hu.system.mapper.StockInboundMapper;
import com.hu.system.mapper.StockReturnMapper;
import com.hu.system.mapper.StockOutboundMapper;
import com.hu.system.mapper.ProfitReturnMapper;
import com.hu.system.mapper.ProfitAftersaleMapper;
import com.hu.system.mapper.SysUserShopMapper;
import com.hu.system.service.IProductInfoService;

/**
 * 产品信息Service业务层处理
 *
 * @author hu
 * @date 2025-01-21
 */
@Service
public class ProductInfoServiceImpl implements IProductInfoService {
    @Autowired
    private ProductInfoMapper productInfoMapper;

    @Autowired
    private SysUserShopMapper userShopMapper;

    @Autowired
    private PurchaseInboundMapper purchaseInboundMapper;

    @Autowired
    private StockInboundMapper stockInboundMapper;

    @Autowired
    private StockReturnMapper stockReturnMapper;

    @Autowired
    private StockOutboundMapper stockOutboundMapper;

    @Autowired
    private ProfitReturnMapper profitReturnMapper;

    @Autowired
    private ProfitAftersaleMapper profitAftersaleMapper;

    /**
     * 查询产品信息列表（带数据权限过滤）
     *
     * @param productInfo 产品信息
     * @return 产品信息
     */
    @Override
    public List<ProductInfo> selectProductInfoList(ProductInfo productInfo) {
        Long userId = SecurityUtils.getUserId();

        // 管理员查看全部产品
        if (userId != null && userId == 1L) {
            return productInfoMapper.selectProductInfoList(productInfo);
        }

        // 普通用户根据绑定的店铺过滤产品
        // 保存分页参数（因为查询店铺ID会消耗分页参数）
        com.github.pagehelper.Page<?> page = PageHelper.getLocalPage();
        // 清除分页参数，让店铺ID查询不使用分页
        PageHelper.clearPage();
        List<Long> shopIds = userShopMapper.selectShopIdsByUserId(userId);
        // 恢复分页参数，让主查询使用分页
        if (page != null) {
            PageHelper.startPage(page.getPageNum(), page.getPageSize(), page.getOrderBy());
        }
        if (shopIds == null || shopIds.isEmpty()) {
            // 用户未绑定任何店铺，返回空列表
            return new ArrayList<>();
        }

        // 通过params传递shopIdList给Mapper
        productInfo.getParams().put("shopIdList", shopIds);
        return productInfoMapper.selectProductInfoList(productInfo);
    }

    /**
     * 查询产品信息（带数据权限校验）
     *
     * @param productId 产品信息主键
     * @return 产品信息
     */
    @Override
    public ProductInfo selectProductInfoByProductId(Long productId) {
        ProductInfo product = productInfoMapper.selectProductInfoByProductId(productId);
        if (product == null) {
            return null;
        }

        Long userId = SecurityUtils.getUserId();

        // 管理员可查看全部
        if (userId != null && userId == 1L) {
            return product;
        }

        // 普通用户校验是否有权限查看该产品（此处不需要分页，但为统一起见也处理）
        List<Long> userShopIds = userShopMapper.selectShopIdsByUserId(userId);
        if (userShopIds == null || userShopIds.isEmpty()) {
            return null;
        }

        // 检查产品的店铺ID是否在用户绑定的店铺中
        if (product.getShopId() != null && userShopIds.contains(product.getShopId())) {
            return product;
        }

        return null;
    }

    /**
     * 校验SKU编码是否唯一
     *
     * @param sku       SKU编码
     * @param productId 产品ID（编辑时传入，新增时为null）
     * @return 结果 true唯一 false不唯一
     */
    @Override
    public boolean checkSkuUnique(String sku, Long productId) {
        ProductInfo product = productInfoMapper.selectProductInfoBySku(sku);
        if (product == null) {
            return true;
        }
        // 编辑时，如果是当前产品，则认为唯一
        if (productId != null && product.getProductId().equals(productId)) {
            return true;
        }
        return false;
    }

    /**
     * 新增产品信息
     *
     * @param productInfo 产品信息
     * @return 结果
     */
    @Override
    @Transactional
    public int insertProductInfo(ProductInfo productInfo) {
        // SKU唯一性校验
        if (!checkSkuUnique(productInfo.getSku(), null)) {
            throw new ServiceException("SKU编码[" + productInfo.getSku() + "]已存在");
        }

        productInfo.setDelFlag("0");
        productInfo.setCreateBy(SecurityUtils.getUsername());
        return productInfoMapper.insertProductInfo(productInfo);
    }

    /**
     * 修改产品信息（带数据权限校验）
     *
     * @param productInfo 产品信息
     * @return 结果
     */
    @Override
    @Transactional
    public int updateProductInfo(ProductInfo productInfo) {
        Long userId = SecurityUtils.getUserId();

        // 管理员可修改全部
        if (userId == null || userId != 1L) {
            // 普通用户只能修改绑定店铺的产品
            ProductInfo existProduct = selectProductInfoByProductId(productInfo.getProductId());
            if (existProduct == null) {
                throw new ServiceException("您没有权限修改该产品");
            }
        }

        // SKU唯一性校验（如果SKU被修改）
        if (!checkSkuUnique(productInfo.getSku(), productInfo.getProductId())) {
            throw new ServiceException("SKU编码[" + productInfo.getSku() + "]已存在");
        }

        productInfo.setUpdateBy(SecurityUtils.getUsername());
        return productInfoMapper.updateProductInfo(productInfo);
    }

    /**
     * 批量删除产品信息（带数据权限校验和级联删除）
     *
     * @param productIds 需要删除的产品信息主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteProductInfoByProductIds(Long[] productIds) {
        Long userId = SecurityUtils.getUserId();

        // 管理员可删除全部
        if (userId == null || userId != 1L) {
            // 普通用户只能删除绑定店铺的产品
            for (Long productId : productIds) {
                ProductInfo product = selectProductInfoByProductId(productId);
                if (product == null) {
                    throw new ServiceException("您没有权限删除部分产品");
                }
            }
        }

        // 获取要删除的产品的SKU列表
        List<String> skus = productInfoMapper.selectSkusByProductIds(productIds);

        if (skus != null && !skus.isEmpty()) {
            // 级联删除相关数据（软删除）
            // 1. 删除采购入库记录
            purchaseInboundMapper.deletePurchaseInboundBySkus(skus);

            // 2. 删除库存入库记录
            stockInboundMapper.deleteStockInboundBySkus(skus);

            // 3. 删除退货入库记录
            stockReturnMapper.deleteStockReturnBySkus(skus);

            // 4. 删除备货出库记录
            stockOutboundMapper.deleteStockOutboundBySkus(skus);

            // 5. 删除回款明细
            profitReturnMapper.deleteProfitReturnBySkus(skus);

            // 6. 删除售后明细
            profitAftersaleMapper.deleteProfitAftersaleBySkus(skus);
        }

        // 最后删除产品本身
        return productInfoMapper.deleteProductInfoByProductIds(productIds);
    }

    /**
     * 根据SKU查询产品信息
     *
     * @param sku SKU编码
     * @return 产品信息
     */
    @Override
    public ProductInfo selectProductInfoBySku(String sku) {
        return productInfoMapper.selectProductInfoBySku(sku);
    }

    @Override
    public ProductInfo selectProductInfoBySkuAndShopId(String sku, Long shopId) {
        return productInfoMapper.selectProductInfoBySkuAndShopId(sku, shopId);
    }

    /**
     * 导入时自动创建或更新产品（默认更新已存在的产品）
     *
     * @param sku           SKU编码
     * @param productName   产品名称
     * @param skuAttr       SKU属性
     * @param skuCode       SKU货号（如果为空则使用sku作为默认值）
     * @param shopId        所属店铺ID
     * @return 产品操作结果（包含产品信息和操作类型）
     */
    @Override
    @Transactional
    public com.hu.system.domain.ProductOperationResult getOrCreateProduct(String sku, String productName, String skuAttr, String skuCode, Long shopId) {
        // SKU货号为空时，使用SKU编码作为默认值
        if (StringUtils.isEmpty(skuCode)) {
            skuCode = sku;
        }
        // 先查询是否存在（按SKU和店铺ID查询，包括软删除的记录）
        ProductInfo product = productInfoMapper.selectProductInfoBySkuAndShopId(sku, shopId);

        if (product != null) {
            // 如果是已删除的记录，恢复它
            if ("2".equals(product.getDelFlag())) {
                product.setDelFlag("0");
                product.setUpdateBy(SecurityUtils.getUsername());
                // 同时更新产品信息
                if (StringUtils.isNotEmpty(productName)) {
                    product.setProductName(productName);
                }
                if (StringUtils.isNotEmpty(skuAttr)) {
                    product.setSkuAttr(skuAttr);
                }
                // 更新SKU货号
                product.setSkuCode(skuCode);
                productInfoMapper.updateProductInfo(product);
                return new com.hu.system.domain.ProductOperationResult(
                    product, 
                    com.hu.system.domain.ProductOperationResult.OperationType.UPDATED,
                    "恢复已删除产品"
                );
            }
            
            // 默认始终更新产品信息（只更新非空字段）
            boolean needUpdate = false;
            java.util.List<String> updatedFields = new java.util.ArrayList<>();
            
            // 产品名称：如果导入数据有值且与现有数据不同，则更新
            if (StringUtils.isNotEmpty(productName) && !productName.equals(product.getProductName())) {
                String oldName = product.getProductName();
                product.setProductName(productName);
                updatedFields.add("产品名称[" + oldName + "→" + productName + "]");
                needUpdate = true;
            }
            
            // SKU属性：如果导入数据有值且与现有数据不同，则更新
            if (StringUtils.isNotEmpty(skuAttr) && !skuAttr.equals(product.getSkuAttr())) {
                String oldAttr = product.getSkuAttr();
                product.setSkuAttr(skuAttr);
                updatedFields.add("SKU属性[" + oldAttr + "→" + skuAttr + "]");
                needUpdate = true;
            }
            
            // SKU货号：如果与现有数据不同，则更新
            if (!skuCode.equals(product.getSkuCode())) {
                String oldCode = product.getSkuCode();
                product.setSkuCode(skuCode);
                updatedFields.add("SKU货号[" + oldCode + "→" + skuCode + "]");
                needUpdate = true;
            }
            
            // 如果有字段需要更新，执行更新操作
            if (needUpdate) {
                product.setUpdateBy(SecurityUtils.getUsername());
                productInfoMapper.updateProductInfo(product);
                String updateDesc = String.join("、", updatedFields);
                return new com.hu.system.domain.ProductOperationResult(
                    product, 
                    com.hu.system.domain.ProductOperationResult.OperationType.UPDATED,
                    updateDesc
                );
            }
            
            // 无变化
            return new com.hu.system.domain.ProductOperationResult(
                product, 
                com.hu.system.domain.ProductOperationResult.OperationType.UNCHANGED
            );
        }

        // 不存在则自动创建
        product = new ProductInfo();
        product.setSku(sku);
        product.setSkuCode(skuCode); // SKU货号（如果原本为空已被设置为sku）
        product.setProductName(productName != null ? productName : "自动导入产品");
        product.setSkuAttr(skuAttr != null ? skuAttr : "默认属性");
        product.setPriceCheck(java.math.BigDecimal.ZERO); // 默认核价为0
        product.setProductStatus("3"); // 默认状态：上新备货
        product.setShopId(shopId);
        product.setDelFlag("0");
        product.setCreateBy(SecurityUtils.getUsername());

        try {
            productInfoMapper.insertProductInfo(product);
        } catch (org.springframework.dao.DuplicateKeyException e) {
            // 并发场景或软删除记录存在：重新查询返回（按SKU和店铺ID查询）
            product = productInfoMapper.selectProductInfoBySkuAndShopId(sku, shopId);
            if (product == null) {
                // 理论上不会发生，但为了健壮性还是抛出异常
                throw new com.hu.common.exception.ServiceException("产品[" + sku + "]在店铺[" + shopId + "]中创建失败，请重试");
            }
            
            // 如果查到的是软删除记录，恢复它
            if ("2".equals(product.getDelFlag())) {
                product.setDelFlag("0");
                product.setUpdateBy(SecurityUtils.getUsername());
                // 更新产品信息
                if (StringUtils.isNotEmpty(productName)) {
                    product.setProductName(productName);
                }
                if (StringUtils.isNotEmpty(skuAttr)) {
                    product.setSkuAttr(skuAttr);
                }
                productInfoMapper.updateProductInfo(product);
                return new com.hu.system.domain.ProductOperationResult(
                    product, 
                    com.hu.system.domain.ProductOperationResult.OperationType.UPDATED,
                    "恢复已删除产品"
                );
            }
            
            // 并发创建的情况视为无变化
            return new com.hu.system.domain.ProductOperationResult(
                product, 
                com.hu.system.domain.ProductOperationResult.OperationType.UNCHANGED
            );
        }

        return new com.hu.system.domain.ProductOperationResult(
            product, 
            com.hu.system.domain.ProductOperationResult.OperationType.CREATED
        );
    }

    /**
     * 批量修改产品状态
     *
     * @param productIds     产品ID数组
     * @param productStatus  产品状态
     * @return 结果
     */
    @Override
    @Transactional
    public int updateProductStatus(Long[] productIds, String productStatus) {
        if (productIds == null || productIds.length == 0) {
            return 0;
        }

        int count = 0;
        String updateBy = SecurityUtils.getUsername();

        for (Long productId : productIds) {
            // 数据权限校验
            ProductInfo product = selectProductInfoByProductId(productId);
            if (product != null) {
                product.setProductStatus(productStatus);
                product.setUpdateBy(updateBy);
                count += productInfoMapper.updateProductInfo(product);
            }
        }

        return count;
    }
}

